
El algoritmo consiste en tomar cada una de las subsecuencias posibles de izquierda a derecha y de derecha a izquierda(estas siempre contienen a una de las puntas) y ver si sumando esos números más mis puntos en los subjuegos siguientes se obtiene la mayor diferencia con el score del otro jugador. 
\\
\\
Para la instancia de tamaño $n$ el algoritmo hará $2n$ llamadas recursivas. Una para cada subsecuencia posible. 
Comenzando desde izquierda, son $n$ y comenzando desde derecha son otras $n$ también. \\

Por ejemplo al tener la instancia [1,2,3,4], la instancia [2,3], será calculada una sola vez y guardarda en una matriz con las coordenadas
[1,3]. \\
Cada vez que un subjuego intente tomar una decisión en base al resultado parcial que contiene la sub secuencia [2,3], utilizará este resultado para no recalcularlo. \\

Para cada i desde 1 a longitud de secuencia, sumo desde 0 a i ó desde longitud -1 a -i (i items desde el final) en 
caso de sumar desde derecha, y llamo recursivamente a la función con el resto de secuencia que dejo luego de la suma. \\
Por ejemplo, en el paso i = 2  con secuencia [1,2,3,4,5,6], sumo 1+2 y llamo recursivamente con [3,4,5,6] y el turno asignado al otro jugador.
Cada suma cuesta $O(1)$, porque se utiliza el valor sumado en la iteración $i-1$. La extracción de los items sumados también cuesta $O(1)$, porque solo se mueven índices.
La llamada recursiva, en caso de ya estar calculada en la matriz cuesta $O(1)$, caso contrario cuesta $F(n-i)$. \\

Ahora encarando la complejidad desde la matriz de resultados parciales se puede ver más claramente. 
Vamos a tener $N$ subjuegos de longitud 1 con K constante la complejidad de resolución de cada uno de estos. 
Luego $N-1$ juegos de longitud 2, $N-2$ de longitud 3 y así sucesivamente. Serán para cada subjuego entonces $N-i$ de longitud $i+1$ \\
Si para cada uno de estos juegos tengo complejidad K, dado que utilizo los 
resultados anteriores, entonces la fórmula es $\sum\limits$$_{j=0}^{n-1} K*n-j$,  o sea, $K*n(n-1)/2$ que es $O(n^2/2)$ \\


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% \subsubsection{pseudocodigo}

% Siendo J el objeto Juego y la funcion Jugar que toma como parametro
% un Juego. \\
% El objeto Juego contiene:\\
% turno $\leftarrow$ 0 o 1 segun a quien le toque \\
% jugador $\leftarrow$ que jugador se toma como el propio\\ 
% scores $\leftarrow$ puntaje de jugador 0 y jugador 1 \\
% numeros $\leftarrow$ secuencia de numeros disponibles en la mesa \\

% Entonces:
% \begin{verbatim}

% Jugar(Juego)

% //i que maximiza mi score con respecto al otro
% MaxDiffI = 0
% MaxDiffIVal = INT_MIN
% MaxIJuego = 0;

% Para i en 1 -> n-1 
%    JuegoIzq = JuegoDer = Juego
%    //Preparo la llamada recursiva a izquierda
%    sumIzq = Sumar desde 1 a i los numeros de Juego
%    Sacar( desde 1 a i ) en los numeros de JuegoIzq
%    resetear scores a o en JuegoIzq
%    pasar turno al otro jugador en JuegoIzq
%    //llamada recursiva subsecuencia desde la izquierda
%    JuegoIzq = Jugar(Juego') 
   
%    //Preparo la llamada recursiva a derecha
%    sumDer = Sumar desde 1 a i los numeros de Juego
%    Sacar( desde 1 a i ) en los numeros de JuegoDer
%    resetear scores a o en JuegoDer
%    pasar turno al otro jugador en JuegoDer
%    //llamada recursiva subsecuencia desde la derecha
%    JuegoDer = Jugar(Juego') 

%    //evaluo que subsecuencia es mejor y trato de ver si es mejor 
%    //que las que ya procese para i menores que el actual
%    Si sumIzq + JuegoIzq.scores[mio] - JuegoIzq.scores[elOtro] > MaxdiffIVal Y
%       sumIzq + JuegoIzq.scores[mio] - JuegoIzq.scores[elOtro] > sumDer + JuegoDer.scores[mio] - JuegoDer.scores[elOtro] 

%       MaxDiffI <- i
%       MaxDiffIVall <-- sumIzq + JuegoIzq.scores[mio] - JuegoIzq.scores[elOtro]
%       MaxIJuego <- JuegoIzq
%    fin Si
%    Si sumDer + JuegoDer.scores[mio] - JuegoDer.scores[elOtro] > MaxdiffIVal Y
%       sumDer + JuegoDer.scores[mio] - JuegoDer.scores[elOtro] > sumIzq + JuegoIzq.scores[mio] - JuegoIzq.scores[elOtro] 
%       MaxDiffI <- -i
%       MaxDiffIVall <-- sumDer + JuegoDer.scores[mio] - JuegoDer.scores[elOtro]
%       MaxIJuego <- JuegoDer
%     fin Si
% Fin Para

% Actualizo MaxIJuego con :
%    Sumo s  la suma que saque en MaxDiffI 
%    Sumo 1 a la cantidad de turnos jugados en

% Retornar MaxIJuego
% \end{verbatim}
